home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung 2 / Power-Programmierung CD 2 (Tewi)(1994).iso / c / library / dos / grafik / gif386 / gif386.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-12-04  |  6.7 KB  |  359 lines
  1. #define        MAIN
  2. #include    <msdos.cf>
  3. #include    "gif386.h"
  4.  
  5. _far char      *screen;            /* pointer to display memory */
  6. int    SWidth,SHeight;
  7.  
  8. _packed struct    dta    {
  9.     char        ff_reserved[21];
  10.     char        ff_attrib;
  11.     unsigned short    ff_ftime;
  12.     unsigned short    ff_fdate;
  13.     long        ff_fsize;
  14.     char        ff_name[13];
  15. } DTA ;
  16.  
  17. main(int argc,char **argv)    {
  18. extern    char *Image;
  19. char    fn[65];
  20. int    bDone = 0;
  21. int    device;
  22.  
  23.     if (argc == 1)    {
  24.         fprintf(stderr,"usage: gif386 [device] giffile\n");
  25.         fprintf(stderr,"where    device =\n");
  26.         fprintf(stderr,"o    orchid\n");
  27.         fprintf(stderr,"e    everex\n");
  28.         fprintf(stderr,"v    video7\n");
  29.         fprintf(stderr,"p    paradise\n");
  30.         fprintf(stderr,"g    generic (default)\n");
  31.         exit(1);
  32.     }
  33.  
  34.     findfirst(fn,argv[argc - 1]);
  35.  
  36.     LoadGIF(fn);
  37.  
  38.     if (argc == 3)
  39.         device = set_device(argv[1][0]);
  40.     else
  41.         device = set_device('g');        
  42.  
  43.     while (1)    {
  44.         bDone = !DoDisplay(Image,device);
  45.  
  46.         if (bDone)    
  47.             break;
  48.  
  49.         findnext(fn,argv[argc - 1]);
  50.  
  51.         LoadGIF(fn);
  52.     }
  53.  
  54.     restore_palette();
  55.     restore_screen();
  56. }
  57.  
  58.  
  59. int    restore_palette()    {
  60.  
  61. }
  62.  
  63. int    restore_screen()    {
  64.  
  65.     Registers.AX.LH.H = 0;
  66.     Registers.AX.LH.L = 0x03;
  67.     callint(0x10);    
  68. }
  69.  
  70. int    set_device(char d)    {
  71. int    device;
  72.     
  73.     /*
  74.      * 0x1c is the Phar Lap DOS|Extender selector for the screen.
  75.      */
  76.      
  77.     ((struct overlay *) &screen)->seg = 0x1c;
  78.     ((struct overlay *) &screen)->off = 0;
  79.  
  80. /*    
  81.     Registers.AX.LH.H = 0x10;
  82.     Registers.AX.LH.L = 0x13;    
  83.     Registers.BX.W    = 0;
  84.     callint(0x10);
  85. */    
  86.  
  87.     switch(d)    {
  88.         case 'o':
  89.             SWidth = HWIDTH;
  90.             SHeight= HHEIGHT;
  91.                Registers.AX.LH.H = 0;
  92.             Registers.AX.LH.L = 0x30; /* 800 X 600 X 256 mode */
  93.             callint(0x10);
  94.             device = TSENG;
  95.         break;            
  96.  
  97.         default:
  98.             SWidth = LWIDTH;
  99.             SHeight= LHEIGHT;
  100.                Registers.AX.LH.H = 0;
  101.             Registers.AX.LH.L = 0x13; /* 320 X 200 X 256 mode */
  102.             callint(0x10);
  103.             device = GENERIC;
  104.         break;                    
  105.     }
  106.  
  107.     return device;
  108. }    
  109.  
  110. setup_palette()    {
  111. extern    byte Red[256],Green[256],Blue[256],used[256];
  112. extern  int    numused;
  113. register int    color;
  114. double    R,G,B;
  115. byte    r,g,b;
  116.  
  117.     for (color = 0;color < 256;color++)    {
  118.         if (used[color])    {
  119.  
  120.                Registers.AX.LH.H = 0x10;
  121.                Registers.AX.LH.L = 0x10;
  122.             Registers.BX.W    = (short)color;
  123.  
  124.             R = 63.0 * ((double)Red[color] / 255.0);
  125.             r = (byte)R;
  126.  
  127.             G = 63.0 * ((double)Green[color] / 255.0);
  128.             g = (byte)G;
  129.  
  130.             B = 63.0 * ((double)Blue[color] / 255.0);
  131.             b = (byte)B;        
  132.  
  133.             Registers.DX.LH.H = r;
  134.             Registers.CX.LH.H = g;
  135.             Registers.CX.LH.L = b;
  136.  
  137.             callint(0x10);
  138.         }
  139.     }
  140. }
  141.  
  142. DoDisplay(char *image,int device)    {
  143. extern    int    Width,Height;
  144. int    x,y,bQuit,bDontDraw,bNext;
  145.  
  146.     x = 0;
  147.     y = 0;
  148.     bQuit = 0;
  149.     bDontDraw = 0;
  150.     bNext = 0;
  151.     
  152.     setup_palette();
  153.  
  154.     while(1)    {
  155.         if (!bDontDraw)
  156.             BitBlt(SWidth,SHeight,x,y,Width,Height,image,device);
  157.  
  158.         bDontDraw = 0;    
  159.  
  160.         /* get key */
  161.         Registers.AX.LH.H = 0;
  162.         callint(0x16);
  163.  
  164.         if (Registers.AX.LH.L == 0)    
  165.         switch(Registers.AX.LH.H)    {
  166.             case 72:    y--; break;
  167.             case 80:    y++; break;
  168.             case 77:    x++; break;
  169.             case 75:    x--; break;            
  170.  
  171.             case 73:    y-=10; break;
  172.             case 81:    y+=10; break;
  173.             case 116:    x+=10; break;
  174.             case 115:    x-=10; break;
  175.             case 82:    changepalette(1); bDontDraw = 1; break;
  176.             case 83:    changepalette(-1); bDontDraw = 1; break;
  177.             case 60:    pan(x,y,image,device); break;
  178.         }
  179.         else
  180.             switch(Registers.AX.LH.L)    {
  181.                 case 'q':
  182.                 case 27:    bQuit = 1; break;
  183.                 case 'n':    bNext = 1; break;
  184.                 case 'g':    grayscalesum(); bDontDraw = 1; break;
  185.                 case 's':    smooth(Width,Height,image);
  186.             }
  187.  
  188.         if (x < 0)    x = 0;
  189.         if (y < 0)    y = 0;
  190.         if (y > (Height - SHeight)) y = Height - SHeight;
  191.         
  192.         if (bQuit || bNext)
  193.             break;
  194.  
  195.     }
  196.  
  197.     return bNext;    
  198. }
  199.  
  200.  
  201. BitBlt(int swidth,int sheight,int ix,int iy,int iwidth,int iheight,char *image,int device) {
  202. register int pixel,count,scan,ioffset;
  203. int    width,height;
  204. short    bank;
  205.  
  206.     width = (iwidth < swidth) ? iwidth : swidth;
  207.     height= (iheight< sheight)? iheight: sheight;
  208.  
  209.     count = 0;
  210.     bank  = 0;
  211.     ioffset = iy * iwidth + ix;
  212.     SetBank(device,bank);
  213.     
  214.     for (scan = 0;scan < height;scan++)    {
  215.         for (pixel = 0;pixel < swidth;pixel++)    {
  216.             screen[count++] =
  217.                 (pixel < width) ?
  218.                 image[ioffset + pixel] :
  219.                 0;
  220.                 
  221.             if (count & 0x10000)    {
  222.                 SetBank(device,++bank);
  223.                 count = 0;
  224.             }
  225.         }
  226.  
  227.         ioffset += iwidth;
  228.     }
  229. }
  230.  
  231. changepalette(int amount)    {
  232. register int    color;
  233. extern byte    used[256];
  234. int    r,g,b;
  235.  
  236.     /* set up palette */
  237.  
  238.     for (color = 0;color < 256;color++)    {
  239.         if (used[color])    {
  240.         
  241.             r = Red[color];
  242.             g = Green[color];
  243.             b = Blue[color];
  244.  
  245.             r += amount;
  246.             g += amount;
  247.             b += amount;
  248.  
  249.             if (r > 255)    r = 255;
  250.             if (g > 255)    g = 255;
  251.             if (b > 255)    b = 255;
  252.  
  253.             if (r < 0)    r = 0;
  254.             if (g < 0)    g = 0;
  255.             if (b < 0)    b = 0;
  256.             
  257.             Red[color] = r;
  258.             Green[color]=g;
  259.             Blue[color]=b;
  260.         }
  261.     }
  262.     setup_palette();
  263. }
  264.  
  265. grayscalesum()    {
  266.     Registers.AX.LH.H = 0x10;
  267.     Registers.AX.LH.L = 0x1b;
  268.     Registers.BX.W    = 0;
  269.     Registers.CX.W    = 256;
  270.     callint(0x10);
  271. }
  272.  
  273.  
  274. smooth(int width,int height,char *image)    {
  275. register int    row,col,val,offset;
  276.  
  277.     for (row = 1;row < height - 1;row++)    {
  278.         offset = row * width;
  279.         
  280.         for (col = 1;col < width - 1;col++)    {
  281.             val =
  282.                 image[offset + col - 1] +    
  283.                 image[offset + col + 1] +
  284.                 image[offset - width + col - 1] +
  285.                 image[offset - width + col + 1] +
  286.                 image[offset - width + col] +
  287.                 image[offset + width + col + 1] +
  288.                 image[offset + width + col - 1] +
  289.                 image[offset + width + col];
  290.  
  291.             image[offset + col] = val >> 3;                
  292.         }
  293.     }
  294. }
  295.  
  296. pan(int x,int y,char *image,int device)    {
  297. register int i;
  298. extern     int Width,Height;    
  299.  
  300.     for (i = y;i <= (Height - SHeight);i++)
  301.     BitBlt(SWidth,SHeight,x,i,Width,Height,image,device);
  302.     for (;i >= 0;i--)
  303.     BitBlt(SWidth,SHeight,x,i,Width,Height,image,device);
  304.     for (;i <= y;i++)    
  305.     BitBlt(SWidth,SHeight,x,i,Width,Height,image,device);
  306. }
  307.  
  308.  
  309. findfirst(char *fn,char *fs)    {
  310. char    temp[64];
  311. char    *ptr;
  312.         
  313.     Registers.AX.LH.H = 0x1A;
  314.     Registers.DX.R = (unsigned int)(&DTA);
  315.     Registers.DS.R = 0x14;
  316.     
  317.     callint(0x21);
  318.  
  319.     Registers.AX.LH.H = 0x4E;
  320.     Registers.CX.W    = 0;
  321.     Registers.DS.R = 0x14;
  322.     Registers.DX.R = (unsigned int)fs;
  323.  
  324.     callint(0x21);
  325.  
  326.     strcpy(temp,fs);
  327.     ptr = (char *)strrchr(temp,'\\');
  328.  
  329.     if (ptr != NULL)    {
  330.         *(ptr + 1) = '\0';
  331.         strcat(temp,DTA.ff_name);
  332.         strcpy(fn,temp);
  333.     } else 
  334.         strcpy(fn,DTA.ff_name);    
  335. }
  336.  
  337.  
  338. findnext(char *fn,char *fs)    {
  339. char    temp[64];
  340. char    *ptr;
  341.  
  342.     Registers.AX.LH.H = 0x4F;
  343.     Registers.DS.R = 0x14;
  344.  
  345.     callint(0x21);
  346.     strcpy(fn,DTA.ff_name);
  347.  
  348.     strcpy(temp,fs);
  349.     ptr = (char *)strrchr(temp,'\\');
  350.  
  351.     if (ptr != NULL)    {
  352.         *(ptr + 1) = '\0';
  353.         strcat(temp,DTA.ff_name);
  354.         strcpy(fn,temp);
  355.     } else 
  356.         strcpy(fn,DTA.ff_name);    
  357.     
  358. }
  359.